In [68]:
import numpy as np # linear algebra
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import tensorflow as tf
from PIL import Image
from keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.models import Sequential
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout, ReLU, MaxPool2D, GlobalAvgPool2D
from tensorflow.keras.layers import Input, Add, ZeroPadding2D, Activation, BatchNormalization, Flatten, Conv2D, AveragePooling2D, GlobalMaxPooling2D, GlobalAveragePooling2D
from tensorflow.keras.initializers import glorot_uniform
from tensorflow.keras.models import Model
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import OneHotEncoder

Data Preprocessing¶

In [69]:
supp_dir = '/kaggle/input/ubc-ovarian-cancer-competition-supplemental-masks'
data_dir = '/kaggle/input/UBC-OCEAN'

train_csv = pd.read_csv(data_dir + '/train.csv')
test_csv = pd.read_csv(data_dir + '/test.csv')
In [70]:
#filter for WSI
train_csv = train_csv[train_csv['is_tma'] == False]
train_data, val_data = train_test_split(train_csv, test_size=0.2, random_state=42, stratify = train_csv['label'])

#image paths
train_image_paths = [data_dir + '/train_thumbnails/' + str(img_id) + '_thumbnail.png' for img_id in train_data['image_id']]
val_image_paths = [data_dir + '/train_thumbnails/' + str(img_id) + '_thumbnail.png' for img_id in val_data['image_id']]
test_image_paths = [data_dir + '/test_thumbnails/' + str(img_id) + '_thumbnail.png' for img_id in test_csv['image_id']]

#multi-class classification: encoding labels for model (one-hot encoding)
one_hot_encoder = OneHotEncoder(sparse_output=False)

# Reshape the labels to a 2D array before applying OneHotEncoder
train_labels = np.array(train_data['label'])
val_labels = np.array(val_data['label'])

train_labels_reshaped = train_labels.reshape(-1, 1)
val_labels_reshaped = val_labels.reshape(-1, 1)

train_labels_one_hot = one_hot_encoder.fit_transform(train_labels_reshaped)
val_labels_one_hot = one_hot_encoder.transform(val_labels_reshaped)


#print(test_labels_one_hot)
#print(val_labels_one_hot)
In [71]:
#(1) feature scales first (all pixel values are now between 0 and 1), image augmentation transforms (shear_range, zoom_range, horizontal_flip) to prevent overfitting
datagen = ImageDataGenerator(rescale = 1./255,
                                   #shear_range = 0.2,
                                   #zoom_range = 0.2,
                                   horizontal_flip = True
                            )

def load_and_augment_img(img_path):
    img = Image.open(img_path)
    img = img.resize((224, 224))  # Resize to desired dimensions
    img = np.array(img)  # Convert to numpy array
    img = img.reshape((1,) + img.shape)  # Reshape to (1, height, width, channels) for flow()
    img = datagen.flow(img, batch_size=1).next()  # Apply data augmentation
    return img[0]

# Apply data augmentation to training, validation, and test images
train_images_augmented = [load_and_augment_img(path) for path in train_image_paths]
val_images_augmented = [load_and_augment_img(path) for path in val_image_paths]
test_images_augmented = [load_and_augment_img(path) for path in test_image_paths]
In [72]:
import matplotlib.pyplot as plt
def visualize(image):
    plt.figure(figsize=(10, 10))
    plt.axis('off')
    plt.imshow(image)
In [73]:
from IPython.display import Image
Image(filename=train_image_paths[0], width=768, height=768) 
Out[73]:
No description has been provided for this image
In [74]:
visualize(train_images_augmented[0])
No description has been provided for this image

Define ResNet-50 Architecture¶

In [75]:
unique_classes = np.unique(train_labels)
uni_classes = list(unique_classes)
length = len(unique_classes)

print(uni_classes)
['CC', 'EC', 'HGSC', 'LGSC', 'MC']
In [76]:
input_tensor = (224, 224, 3)
NUMBER_OF_CLASSES = 5
In [77]:
# DEFINE THE RESNET-50 ARCHITECTURE *************************************************************

def conv_batchnorm_relu(x, filters, kernel_size, strides=1):
    x = Conv2D(filters=filters, kernel_size=kernel_size, strides=strides, padding = 'same')(x)
    x = BatchNormalization()(x)
    x = ReLU()(x)
    return x

def identity_block(tensor, filters):
    x = conv_batchnorm_relu(tensor, filters=filters, kernel_size=1, strides=1)
    x = conv_batchnorm_relu(x, filters=filters, kernel_size=3, strides=1)
    x = Conv2D(filters=4*filters, kernel_size=1, strides=1)(x)
    x = BatchNormalization()(x)
    x = Add()([tensor,x]) 
    x = ReLU()(x)
    return x

def projection_block(tensor, filters, strides):
    x = conv_batchnorm_relu(tensor, filters=filters, kernel_size=1, strides=strides)     
    x = conv_batchnorm_relu(x, filters=filters, kernel_size=3, strides=1)     
    x = Conv2D(filters=4*filters, kernel_size=1, strides=1)(x)     
    x = BatchNormalization()(x) 
    shortcut = Conv2D(filters=4*filters, kernel_size=1, strides=strides)(tensor)     
    shortcut = BatchNormalization()(shortcut)          
    x = Add()([shortcut,x])       
    x = ReLU()(x)          
    return x 
    
def resnet_block(x, filters, reps, strides):
    x = projection_block(x, filters, strides)
    for _ in range(reps-1):
        x = identity_block(x,filters)
    return x 
In [78]:
input = Input(shape=input_tensor)


x = conv_batchnorm_relu(input, filters=64, kernel_size=7, strides=2)
x = MaxPool2D(pool_size=3, strides=2)(x)
x = resnet_block(x, filters=64, reps=3, strides=1)
x = resnet_block(x, filters=128, reps=4, strides=2)
x = resnet_block(x, filters=256, reps=6, strides=2)
x = resnet_block(x, filters=512, reps=3, strides=2)
x = GlobalAvgPool2D()(x)


output = Dense(NUMBER_OF_CLASSES, activation ='softmax')(x)


model = Model(inputs=input, outputs=output)
In [79]:
model.summary()
Model: "model_4"
__________________________________________________________________________________________________
 Layer (type)                Output Shape                 Param #   Connected to                  
==================================================================================================
 input_5 (InputLayer)        [(None, 224, 224, 3)]        0         []                            
                                                                                                  
 conv2d_212 (Conv2D)         (None, 112, 112, 64)         9472      ['input_5[0][0]']             
                                                                                                  
 batch_normalization_212 (B  (None, 112, 112, 64)         256       ['conv2d_212[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_196 (ReLU)            (None, 112, 112, 64)         0         ['batch_normalization_212[0][0
                                                                    ]']                           
                                                                                                  
 max_pooling2d_4 (MaxPoolin  (None, 55, 55, 64)           0         ['re_lu_196[0][0]']           
 g2D)                                                                                             
                                                                                                  
 conv2d_213 (Conv2D)         (None, 55, 55, 64)           4160      ['max_pooling2d_4[0][0]']     
                                                                                                  
 batch_normalization_213 (B  (None, 55, 55, 64)           256       ['conv2d_213[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_197 (ReLU)            (None, 55, 55, 64)           0         ['batch_normalization_213[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_214 (Conv2D)         (None, 55, 55, 64)           36928     ['re_lu_197[0][0]']           
                                                                                                  
 batch_normalization_214 (B  (None, 55, 55, 64)           256       ['conv2d_214[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_198 (ReLU)            (None, 55, 55, 64)           0         ['batch_normalization_214[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_216 (Conv2D)         (None, 55, 55, 256)          16640     ['max_pooling2d_4[0][0]']     
                                                                                                  
 conv2d_215 (Conv2D)         (None, 55, 55, 256)          16640     ['re_lu_198[0][0]']           
                                                                                                  
 batch_normalization_216 (B  (None, 55, 55, 256)          1024      ['conv2d_216[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 batch_normalization_215 (B  (None, 55, 55, 256)          1024      ['conv2d_215[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 add_64 (Add)                (None, 55, 55, 256)          0         ['batch_normalization_216[0][0
                                                                    ]',                           
                                                                     'batch_normalization_215[0][0
                                                                    ]']                           
                                                                                                  
 re_lu_199 (ReLU)            (None, 55, 55, 256)          0         ['add_64[0][0]']              
                                                                                                  
 conv2d_217 (Conv2D)         (None, 55, 55, 64)           16448     ['re_lu_199[0][0]']           
                                                                                                  
 batch_normalization_217 (B  (None, 55, 55, 64)           256       ['conv2d_217[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_200 (ReLU)            (None, 55, 55, 64)           0         ['batch_normalization_217[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_218 (Conv2D)         (None, 55, 55, 64)           36928     ['re_lu_200[0][0]']           
                                                                                                  
 batch_normalization_218 (B  (None, 55, 55, 64)           256       ['conv2d_218[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_201 (ReLU)            (None, 55, 55, 64)           0         ['batch_normalization_218[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_219 (Conv2D)         (None, 55, 55, 256)          16640     ['re_lu_201[0][0]']           
                                                                                                  
 batch_normalization_219 (B  (None, 55, 55, 256)          1024      ['conv2d_219[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 add_65 (Add)                (None, 55, 55, 256)          0         ['re_lu_199[0][0]',           
                                                                     'batch_normalization_219[0][0
                                                                    ]']                           
                                                                                                  
 re_lu_202 (ReLU)            (None, 55, 55, 256)          0         ['add_65[0][0]']              
                                                                                                  
 conv2d_220 (Conv2D)         (None, 55, 55, 64)           16448     ['re_lu_202[0][0]']           
                                                                                                  
 batch_normalization_220 (B  (None, 55, 55, 64)           256       ['conv2d_220[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_203 (ReLU)            (None, 55, 55, 64)           0         ['batch_normalization_220[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_221 (Conv2D)         (None, 55, 55, 64)           36928     ['re_lu_203[0][0]']           
                                                                                                  
 batch_normalization_221 (B  (None, 55, 55, 64)           256       ['conv2d_221[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_204 (ReLU)            (None, 55, 55, 64)           0         ['batch_normalization_221[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_222 (Conv2D)         (None, 55, 55, 256)          16640     ['re_lu_204[0][0]']           
                                                                                                  
 batch_normalization_222 (B  (None, 55, 55, 256)          1024      ['conv2d_222[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 add_66 (Add)                (None, 55, 55, 256)          0         ['re_lu_202[0][0]',           
                                                                     'batch_normalization_222[0][0
                                                                    ]']                           
                                                                                                  
 re_lu_205 (ReLU)            (None, 55, 55, 256)          0         ['add_66[0][0]']              
                                                                                                  
 conv2d_223 (Conv2D)         (None, 28, 28, 128)          32896     ['re_lu_205[0][0]']           
                                                                                                  
 batch_normalization_223 (B  (None, 28, 28, 128)          512       ['conv2d_223[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_206 (ReLU)            (None, 28, 28, 128)          0         ['batch_normalization_223[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_224 (Conv2D)         (None, 28, 28, 128)          147584    ['re_lu_206[0][0]']           
                                                                                                  
 batch_normalization_224 (B  (None, 28, 28, 128)          512       ['conv2d_224[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_207 (ReLU)            (None, 28, 28, 128)          0         ['batch_normalization_224[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_226 (Conv2D)         (None, 28, 28, 512)          131584    ['re_lu_205[0][0]']           
                                                                                                  
 conv2d_225 (Conv2D)         (None, 28, 28, 512)          66048     ['re_lu_207[0][0]']           
                                                                                                  
 batch_normalization_226 (B  (None, 28, 28, 512)          2048      ['conv2d_226[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 batch_normalization_225 (B  (None, 28, 28, 512)          2048      ['conv2d_225[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 add_67 (Add)                (None, 28, 28, 512)          0         ['batch_normalization_226[0][0
                                                                    ]',                           
                                                                     'batch_normalization_225[0][0
                                                                    ]']                           
                                                                                                  
 re_lu_208 (ReLU)            (None, 28, 28, 512)          0         ['add_67[0][0]']              
                                                                                                  
 conv2d_227 (Conv2D)         (None, 28, 28, 128)          65664     ['re_lu_208[0][0]']           
                                                                                                  
 batch_normalization_227 (B  (None, 28, 28, 128)          512       ['conv2d_227[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_209 (ReLU)            (None, 28, 28, 128)          0         ['batch_normalization_227[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_228 (Conv2D)         (None, 28, 28, 128)          147584    ['re_lu_209[0][0]']           
                                                                                                  
 batch_normalization_228 (B  (None, 28, 28, 128)          512       ['conv2d_228[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_210 (ReLU)            (None, 28, 28, 128)          0         ['batch_normalization_228[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_229 (Conv2D)         (None, 28, 28, 512)          66048     ['re_lu_210[0][0]']           
                                                                                                  
 batch_normalization_229 (B  (None, 28, 28, 512)          2048      ['conv2d_229[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 add_68 (Add)                (None, 28, 28, 512)          0         ['re_lu_208[0][0]',           
                                                                     'batch_normalization_229[0][0
                                                                    ]']                           
                                                                                                  
 re_lu_211 (ReLU)            (None, 28, 28, 512)          0         ['add_68[0][0]']              
                                                                                                  
 conv2d_230 (Conv2D)         (None, 28, 28, 128)          65664     ['re_lu_211[0][0]']           
                                                                                                  
 batch_normalization_230 (B  (None, 28, 28, 128)          512       ['conv2d_230[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_212 (ReLU)            (None, 28, 28, 128)          0         ['batch_normalization_230[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_231 (Conv2D)         (None, 28, 28, 128)          147584    ['re_lu_212[0][0]']           
                                                                                                  
 batch_normalization_231 (B  (None, 28, 28, 128)          512       ['conv2d_231[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_213 (ReLU)            (None, 28, 28, 128)          0         ['batch_normalization_231[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_232 (Conv2D)         (None, 28, 28, 512)          66048     ['re_lu_213[0][0]']           
                                                                                                  
 batch_normalization_232 (B  (None, 28, 28, 512)          2048      ['conv2d_232[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 add_69 (Add)                (None, 28, 28, 512)          0         ['re_lu_211[0][0]',           
                                                                     'batch_normalization_232[0][0
                                                                    ]']                           
                                                                                                  
 re_lu_214 (ReLU)            (None, 28, 28, 512)          0         ['add_69[0][0]']              
                                                                                                  
 conv2d_233 (Conv2D)         (None, 28, 28, 128)          65664     ['re_lu_214[0][0]']           
                                                                                                  
 batch_normalization_233 (B  (None, 28, 28, 128)          512       ['conv2d_233[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_215 (ReLU)            (None, 28, 28, 128)          0         ['batch_normalization_233[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_234 (Conv2D)         (None, 28, 28, 128)          147584    ['re_lu_215[0][0]']           
                                                                                                  
 batch_normalization_234 (B  (None, 28, 28, 128)          512       ['conv2d_234[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_216 (ReLU)            (None, 28, 28, 128)          0         ['batch_normalization_234[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_235 (Conv2D)         (None, 28, 28, 512)          66048     ['re_lu_216[0][0]']           
                                                                                                  
 batch_normalization_235 (B  (None, 28, 28, 512)          2048      ['conv2d_235[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 add_70 (Add)                (None, 28, 28, 512)          0         ['re_lu_214[0][0]',           
                                                                     'batch_normalization_235[0][0
                                                                    ]']                           
                                                                                                  
 re_lu_217 (ReLU)            (None, 28, 28, 512)          0         ['add_70[0][0]']              
                                                                                                  
 conv2d_236 (Conv2D)         (None, 14, 14, 256)          131328    ['re_lu_217[0][0]']           
                                                                                                  
 batch_normalization_236 (B  (None, 14, 14, 256)          1024      ['conv2d_236[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_218 (ReLU)            (None, 14, 14, 256)          0         ['batch_normalization_236[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_237 (Conv2D)         (None, 14, 14, 256)          590080    ['re_lu_218[0][0]']           
                                                                                                  
 batch_normalization_237 (B  (None, 14, 14, 256)          1024      ['conv2d_237[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_219 (ReLU)            (None, 14, 14, 256)          0         ['batch_normalization_237[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_239 (Conv2D)         (None, 14, 14, 1024)         525312    ['re_lu_217[0][0]']           
                                                                                                  
 conv2d_238 (Conv2D)         (None, 14, 14, 1024)         263168    ['re_lu_219[0][0]']           
                                                                                                  
 batch_normalization_239 (B  (None, 14, 14, 1024)         4096      ['conv2d_239[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 batch_normalization_238 (B  (None, 14, 14, 1024)         4096      ['conv2d_238[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 add_71 (Add)                (None, 14, 14, 1024)         0         ['batch_normalization_239[0][0
                                                                    ]',                           
                                                                     'batch_normalization_238[0][0
                                                                    ]']                           
                                                                                                  
 re_lu_220 (ReLU)            (None, 14, 14, 1024)         0         ['add_71[0][0]']              
                                                                                                  
 conv2d_240 (Conv2D)         (None, 14, 14, 256)          262400    ['re_lu_220[0][0]']           
                                                                                                  
 batch_normalization_240 (B  (None, 14, 14, 256)          1024      ['conv2d_240[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_221 (ReLU)            (None, 14, 14, 256)          0         ['batch_normalization_240[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_241 (Conv2D)         (None, 14, 14, 256)          590080    ['re_lu_221[0][0]']           
                                                                                                  
 batch_normalization_241 (B  (None, 14, 14, 256)          1024      ['conv2d_241[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_222 (ReLU)            (None, 14, 14, 256)          0         ['batch_normalization_241[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_242 (Conv2D)         (None, 14, 14, 1024)         263168    ['re_lu_222[0][0]']           
                                                                                                  
 batch_normalization_242 (B  (None, 14, 14, 1024)         4096      ['conv2d_242[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 add_72 (Add)                (None, 14, 14, 1024)         0         ['re_lu_220[0][0]',           
                                                                     'batch_normalization_242[0][0
                                                                    ]']                           
                                                                                                  
 re_lu_223 (ReLU)            (None, 14, 14, 1024)         0         ['add_72[0][0]']              
                                                                                                  
 conv2d_243 (Conv2D)         (None, 14, 14, 256)          262400    ['re_lu_223[0][0]']           
                                                                                                  
 batch_normalization_243 (B  (None, 14, 14, 256)          1024      ['conv2d_243[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_224 (ReLU)            (None, 14, 14, 256)          0         ['batch_normalization_243[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_244 (Conv2D)         (None, 14, 14, 256)          590080    ['re_lu_224[0][0]']           
                                                                                                  
 batch_normalization_244 (B  (None, 14, 14, 256)          1024      ['conv2d_244[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_225 (ReLU)            (None, 14, 14, 256)          0         ['batch_normalization_244[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_245 (Conv2D)         (None, 14, 14, 1024)         263168    ['re_lu_225[0][0]']           
                                                                                                  
 batch_normalization_245 (B  (None, 14, 14, 1024)         4096      ['conv2d_245[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 add_73 (Add)                (None, 14, 14, 1024)         0         ['re_lu_223[0][0]',           
                                                                     'batch_normalization_245[0][0
                                                                    ]']                           
                                                                                                  
 re_lu_226 (ReLU)            (None, 14, 14, 1024)         0         ['add_73[0][0]']              
                                                                                                  
 conv2d_246 (Conv2D)         (None, 14, 14, 256)          262400    ['re_lu_226[0][0]']           
                                                                                                  
 batch_normalization_246 (B  (None, 14, 14, 256)          1024      ['conv2d_246[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_227 (ReLU)            (None, 14, 14, 256)          0         ['batch_normalization_246[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_247 (Conv2D)         (None, 14, 14, 256)          590080    ['re_lu_227[0][0]']           
                                                                                                  
 batch_normalization_247 (B  (None, 14, 14, 256)          1024      ['conv2d_247[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_228 (ReLU)            (None, 14, 14, 256)          0         ['batch_normalization_247[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_248 (Conv2D)         (None, 14, 14, 1024)         263168    ['re_lu_228[0][0]']           
                                                                                                  
 batch_normalization_248 (B  (None, 14, 14, 1024)         4096      ['conv2d_248[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 add_74 (Add)                (None, 14, 14, 1024)         0         ['re_lu_226[0][0]',           
                                                                     'batch_normalization_248[0][0
                                                                    ]']                           
                                                                                                  
 re_lu_229 (ReLU)            (None, 14, 14, 1024)         0         ['add_74[0][0]']              
                                                                                                  
 conv2d_249 (Conv2D)         (None, 14, 14, 256)          262400    ['re_lu_229[0][0]']           
                                                                                                  
 batch_normalization_249 (B  (None, 14, 14, 256)          1024      ['conv2d_249[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_230 (ReLU)            (None, 14, 14, 256)          0         ['batch_normalization_249[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_250 (Conv2D)         (None, 14, 14, 256)          590080    ['re_lu_230[0][0]']           
                                                                                                  
 batch_normalization_250 (B  (None, 14, 14, 256)          1024      ['conv2d_250[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_231 (ReLU)            (None, 14, 14, 256)          0         ['batch_normalization_250[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_251 (Conv2D)         (None, 14, 14, 1024)         263168    ['re_lu_231[0][0]']           
                                                                                                  
 batch_normalization_251 (B  (None, 14, 14, 1024)         4096      ['conv2d_251[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 add_75 (Add)                (None, 14, 14, 1024)         0         ['re_lu_229[0][0]',           
                                                                     'batch_normalization_251[0][0
                                                                    ]']                           
                                                                                                  
 re_lu_232 (ReLU)            (None, 14, 14, 1024)         0         ['add_75[0][0]']              
                                                                                                  
 conv2d_252 (Conv2D)         (None, 14, 14, 256)          262400    ['re_lu_232[0][0]']           
                                                                                                  
 batch_normalization_252 (B  (None, 14, 14, 256)          1024      ['conv2d_252[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_233 (ReLU)            (None, 14, 14, 256)          0         ['batch_normalization_252[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_253 (Conv2D)         (None, 14, 14, 256)          590080    ['re_lu_233[0][0]']           
                                                                                                  
 batch_normalization_253 (B  (None, 14, 14, 256)          1024      ['conv2d_253[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_234 (ReLU)            (None, 14, 14, 256)          0         ['batch_normalization_253[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_254 (Conv2D)         (None, 14, 14, 1024)         263168    ['re_lu_234[0][0]']           
                                                                                                  
 batch_normalization_254 (B  (None, 14, 14, 1024)         4096      ['conv2d_254[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 add_76 (Add)                (None, 14, 14, 1024)         0         ['re_lu_232[0][0]',           
                                                                     'batch_normalization_254[0][0
                                                                    ]']                           
                                                                                                  
 re_lu_235 (ReLU)            (None, 14, 14, 1024)         0         ['add_76[0][0]']              
                                                                                                  
 conv2d_255 (Conv2D)         (None, 7, 7, 512)            524800    ['re_lu_235[0][0]']           
                                                                                                  
 batch_normalization_255 (B  (None, 7, 7, 512)            2048      ['conv2d_255[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_236 (ReLU)            (None, 7, 7, 512)            0         ['batch_normalization_255[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_256 (Conv2D)         (None, 7, 7, 512)            2359808   ['re_lu_236[0][0]']           
                                                                                                  
 batch_normalization_256 (B  (None, 7, 7, 512)            2048      ['conv2d_256[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_237 (ReLU)            (None, 7, 7, 512)            0         ['batch_normalization_256[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_258 (Conv2D)         (None, 7, 7, 2048)           2099200   ['re_lu_235[0][0]']           
                                                                                                  
 conv2d_257 (Conv2D)         (None, 7, 7, 2048)           1050624   ['re_lu_237[0][0]']           
                                                                                                  
 batch_normalization_258 (B  (None, 7, 7, 2048)           8192      ['conv2d_258[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 batch_normalization_257 (B  (None, 7, 7, 2048)           8192      ['conv2d_257[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 add_77 (Add)                (None, 7, 7, 2048)           0         ['batch_normalization_258[0][0
                                                                    ]',                           
                                                                     'batch_normalization_257[0][0
                                                                    ]']                           
                                                                                                  
 re_lu_238 (ReLU)            (None, 7, 7, 2048)           0         ['add_77[0][0]']              
                                                                                                  
 conv2d_259 (Conv2D)         (None, 7, 7, 512)            1049088   ['re_lu_238[0][0]']           
                                                                                                  
 batch_normalization_259 (B  (None, 7, 7, 512)            2048      ['conv2d_259[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_239 (ReLU)            (None, 7, 7, 512)            0         ['batch_normalization_259[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_260 (Conv2D)         (None, 7, 7, 512)            2359808   ['re_lu_239[0][0]']           
                                                                                                  
 batch_normalization_260 (B  (None, 7, 7, 512)            2048      ['conv2d_260[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_240 (ReLU)            (None, 7, 7, 512)            0         ['batch_normalization_260[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_261 (Conv2D)         (None, 7, 7, 2048)           1050624   ['re_lu_240[0][0]']           
                                                                                                  
 batch_normalization_261 (B  (None, 7, 7, 2048)           8192      ['conv2d_261[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 add_78 (Add)                (None, 7, 7, 2048)           0         ['re_lu_238[0][0]',           
                                                                     'batch_normalization_261[0][0
                                                                    ]']                           
                                                                                                  
 re_lu_241 (ReLU)            (None, 7, 7, 2048)           0         ['add_78[0][0]']              
                                                                                                  
 conv2d_262 (Conv2D)         (None, 7, 7, 512)            1049088   ['re_lu_241[0][0]']           
                                                                                                  
 batch_normalization_262 (B  (None, 7, 7, 512)            2048      ['conv2d_262[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_242 (ReLU)            (None, 7, 7, 512)            0         ['batch_normalization_262[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_263 (Conv2D)         (None, 7, 7, 512)            2359808   ['re_lu_242[0][0]']           
                                                                                                  
 batch_normalization_263 (B  (None, 7, 7, 512)            2048      ['conv2d_263[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 re_lu_243 (ReLU)            (None, 7, 7, 512)            0         ['batch_normalization_263[0][0
                                                                    ]']                           
                                                                                                  
 conv2d_264 (Conv2D)         (None, 7, 7, 2048)           1050624   ['re_lu_243[0][0]']           
                                                                                                  
 batch_normalization_264 (B  (None, 7, 7, 2048)           8192      ['conv2d_264[0][0]']          
 atchNormalization)                                                                               
                                                                                                  
 add_79 (Add)                (None, 7, 7, 2048)           0         ['re_lu_241[0][0]',           
                                                                     'batch_normalization_264[0][0
                                                                    ]']                           
                                                                                                  
 re_lu_244 (ReLU)            (None, 7, 7, 2048)           0         ['add_79[0][0]']              
                                                                                                  
 global_average_pooling2d_4  (None, 2048)                 0         ['re_lu_244[0][0]']           
  (GlobalAveragePooling2D)                                                                        
                                                                                                  
 dense_4 (Dense)             (None, 5)                    10245     ['global_average_pooling2d_4[0
                                                                    ][0]']                        
                                                                                                  
==================================================================================================
Total params: 23597957 (90.02 MB)
Trainable params: 23544837 (89.82 MB)
Non-trainable params: 53120 (207.50 KB)
__________________________________________________________________________________________________
In [80]:
'''
from tensorflow.keras.utils import plot_model

plot_model(model)
'''
# NOTE: Dont run this cell unless you want to visually see a graph of network
Out[80]:
'\nfrom tensorflow.keras.utils import plot_model\n\nplot_model(model)\n'
In [81]:
from tensorflow.keras.optimizers import Adam
#from tensorflow.keras.callbacks import EarlyStopping

model.compile(optimizer=Adam(learning_rate=0.001), loss="categorical_crossentropy", metrics=['accuracy'])

results = model.fit(
    np.array(train_images_augmented), train_labels_one_hot,
    epochs=15, 
    batch_size=32,
    validation_data=(np.array(val_images_augmented), val_labels_one_hot ),
)
Epoch 1/15
13/13 [==============================] - 172s 12s/step - loss: 3.1055 - accuracy: 0.3244 - val_loss: 1.7958 - val_accuracy: 0.2330
Epoch 2/15
13/13 [==============================] - 149s 12s/step - loss: 1.7268 - accuracy: 0.3561 - val_loss: 1.4504 - val_accuracy: 0.4272
Epoch 3/15
13/13 [==============================] - 150s 12s/step - loss: 1.5439 - accuracy: 0.4195 - val_loss: 6.9977 - val_accuracy: 0.1845
Epoch 4/15
13/13 [==============================] - 148s 11s/step - loss: 1.3540 - accuracy: 0.4707 - val_loss: 1.5258 - val_accuracy: 0.4272
Epoch 5/15
13/13 [==============================] - 149s 12s/step - loss: 1.1906 - accuracy: 0.5683 - val_loss: 2.0663 - val_accuracy: 0.3301
Epoch 6/15
13/13 [==============================] - 150s 12s/step - loss: 1.1503 - accuracy: 0.5927 - val_loss: 1.5976 - val_accuracy: 0.4272
Epoch 7/15
13/13 [==============================] - 149s 12s/step - loss: 0.8840 - accuracy: 0.6634 - val_loss: 1.6469 - val_accuracy: 0.4272
Epoch 8/15
13/13 [==============================] - 149s 12s/step - loss: 0.8147 - accuracy: 0.7171 - val_loss: 1.8427 - val_accuracy: 0.4272
Epoch 9/15
13/13 [==============================] - 149s 11s/step - loss: 0.6525 - accuracy: 0.7561 - val_loss: 1.6849 - val_accuracy: 0.4272
Epoch 10/15
13/13 [==============================] - 149s 12s/step - loss: 0.6185 - accuracy: 0.7634 - val_loss: 1.8217 - val_accuracy: 0.4272
Epoch 11/15
13/13 [==============================] - 150s 12s/step - loss: 0.6221 - accuracy: 0.7878 - val_loss: 2.6751 - val_accuracy: 0.4272
Epoch 12/15
13/13 [==============================] - 149s 12s/step - loss: 0.5641 - accuracy: 0.7927 - val_loss: 2.7015 - val_accuracy: 0.4272
Epoch 13/15
13/13 [==============================] - 149s 12s/step - loss: 0.2875 - accuracy: 0.9146 - val_loss: 3.4676 - val_accuracy: 0.4272
Epoch 14/15
13/13 [==============================] - 148s 11s/step - loss: 0.2492 - accuracy: 0.9122 - val_loss: 2.1522 - val_accuracy: 0.4272
Epoch 15/15
13/13 [==============================] - 147s 11s/step - loss: 0.2950 - accuracy: 0.9122 - val_loss: 2.5538 - val_accuracy: 0.4272
In [82]:
#SUBMISSION FILE

pred = model.predict(np.array(test_images_augmented))
test = np.argmax(pred,axis=1)
predicted_labels = [uni_classes[i] for i in test]

submission = [[test_csv["image_id"][i], predicted_labels[i]] for i in range(len(test_csv)) ]
df = pd.DataFrame(submission,columns = ["image_id","label"])

df.to_csv("submission.csv", index=False)

#PLOTTING ACCURACY AND LOSS GRAPHS
fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(10, 4))

axes[0].plot(results.history['accuracy'], label = 'Training')
axes[0].plot(results.history['val_accuracy'], label = 'Validation')

axes[0].set_title("Model accuracy")
axes[0].set_xlabel('Epoch')
axes[0].set_ylabel('Accuracy rate')

axes[0].legend()  

axes[1].plot(results.history['loss'], label = 'Training')
axes[1].plot(results.history['val_loss'], label = 'Validation')

axes[1].set_title("Model loss")
axes[1].set_xlabel('Epoch')
axes[1].set_ylabel('Loss')

training_accuracy = results.history['accuracy']
validation_accuracy = results.history['val_accuracy']

overall_training_accuracy = sum(training_accuracy) / len(training_accuracy)
overall_validation_accuracy = sum(validation_accuracy) / len(validation_accuracy)

print(f"Overall Training Accuracy: {overall_training_accuracy}%")
print(f"Overall Validation Accuracy: {overall_validation_accuracy}%")

plt.legend()  
plt.show()
1/1 [==============================] - 3s 3s/step
Overall Training Accuracy: 0.6634146352608998%
Overall Validation Accuracy: 0.39158575733502704%
No description has been provided for this image